/**
 * 用户控制器
 * 处理用户相关的HTTP请求
 */

const { register, updateProfile, changeUserPassword } = require('../services/auth.service');
const { unifiedLogin } = require('../services/unifiedAuth.service');
const { logInfo, logError, logWarning } = require('../logger');
const { generateCode, storeCode, checkRateLimit } = require('../services/verificationService');
const { sendVerificationCode } = require('../services/emailService');

/**
 * 用户注册控制器
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function registerUser(req, res) {
  try {
    // 从请求体获取用户数据
    const userData = req.body;

    // 调用注册服务
    const result = await register(userData);

    // 记录注册日志
    logInfo('用户注册接口调用成功', { userId: result.user.id });

    // 返回成功响应
    return res.status(201).json({
      success: true,
      message: '用户注册成功',
      data: result
    });
  } catch (error) {
    // 记录错误日志
    logError('用户注册接口调用失败', { error: error.message });

    // 返回错误响应
    if (error.message === '邮箱已被注册' || error.message === '用户名已被使用' || error.message === '手机号已被注册') {
      return res.status(409).json({
        success: false,
        message: error.message
      });
    }

    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 用户登录控制器
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function loginUser(req, res) {
  try {
    // 从请求体获取登录凭据
    const { identifier, password, userType } = req.body;

    // 调用统一登录服务
    const result = await unifiedLogin(identifier, password, userType);

    // 记录登录日志
    if (userType === 'admin') {
      logInfo('管理员登录接口调用成功', { adminId: result.user.id });
    } else {
      logInfo('用户登录接口调用成功', { userId: result.user.id });
    }

    // 返回成功响应
    return res.status(200).json({
      success: true,
      message: '登录成功',
      data: result
    });
  } catch (error) {
    // 记录错误日志
    logError('用户登录接口调用失败', { error: error.message });

    // 返回错误响应
    if (error.message === '用户名或密码错误' || error.message === '邮箱或密码错误') {
      return res.status(401).json({
        success: false,
        message: error.message
      });
    }

    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 获取当前用户信息控制器
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function getCurrentUser(req, res) {
  try {
    // 从请求对象获取用户信息（由认证中间件添加）
    const user = req.user;

    // 记录日志
    logInfo('获取当前用户信息接口调用成功', { userId: user.id });

    // 返回用户信息
    return res.status(200).json({
      success: true,
      message: '获取用户信息成功',
      data: {
        user
      }
    });
  } catch (error) {
    // 记录错误日志
    logError('获取当前用户信息接口调用失败', { error: error.message });

    // 返回错误响应
    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 更新用户资料控制器
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function updateUserProfile(req, res) {
  try {
    // 从请求对象获取用户信息（由认证中间件添加）
    const user = req.user;
    
    // 从请求体获取更新数据
    const updateData = req.body;

    // 调用更新服务
    const updatedUser = await updateProfile(user.id, updateData);

    // 记录日志
    logInfo('更新用户资料接口调用成功', { userId: user.id });

    // 返回更新后的用户信息
    return res.status(200).json({
      success: true,
      message: '用户资料更新成功',
      data: {
        user: updatedUser
      }
    });
  } catch (error) {
    // 记录错误日志
    logError('更新用户资料接口调用失败', { error: error.message });

    // 返回错误响应
    if (error.message === '用户不存在' || error.message === '用户名已被使用') {
      return res.status(400).json({
        success: false,
        message: error.message
      });
    }

    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 发送验证码控制器
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function sendVerificationCodeHandler(req, res) {
  try {
    // 从请求体获取邮箱
    const { email } = req.body;

    // 检查邮箱格式
    if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
      return res.status(400).json({
        success: false,
        message: '请输入有效的邮箱地址'
      });
    }

    // 检查发送频率限制（10秒内只能发送一次）
    const rateLimitCheck = await checkRateLimit(email, 10);
    if (!rateLimitCheck.success) {
      return res.status(429).json({
        success: false,
        message: rateLimitCheck.error || '请求过于频繁，请稍后再试'
      });
    }

    // 生成6位随机验证码
    const code = generateCode(6);

    // 存储验证码到数据库
    const storeResult = await storeCode(email, code, 'register', 5);
    if (!storeResult.success) {
      logError('验证码存储失败', { email, error: storeResult.error });
      return res.status(500).json({
        success: false,
        message: '验证码发送失败，请稍后再试'
      });
    }

    // 发送验证码邮件（带重试机制）
    const MAX_RETRIES = 3;
    let retryCount = 0;
    let emailResult;
    
    while (retryCount < MAX_RETRIES) {
      try {
        emailResult = await sendVerificationCode(email, code);
        if (emailResult.success) {
          break;
        }
      } catch (error) {
        retryCount++;
        logWarning('验证码邮件发送失败，正在重试...', { 
          retryCount, 
          error: error.message,
          email 
        });
        
        if (retryCount >= MAX_RETRIES) {
          throw error;
        }
        
        // 等待一段时间后重试
        await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
      }
    }
    
    if (!emailResult.success) {
      logError('验证码邮件发送失败', { email, error: emailResult.error });
      return res.status(500).json({
        success: false,
        message: '验证码发送失败，请稍后再试'
      });
    }

    // 记录日志
    logInfo('验证码发送成功', { email });

    // 返回成功响应
    return res.status(200).json({
      success: true,
      message: '验证码已发送至您的邮箱，请注意查收'
    });
  } catch (error) {
    // 记录错误日志
    logError('发送验证码接口调用失败', { error: error.message });

    // 返回错误响应
    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 修改密码控制器
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function changePassword(req, res) {
  try {
    // 从请求对象获取用户信息（由认证中间件添加）
    const user = req.user;
    
    // 从请求体获取密码数据
    const { currentPassword, newPassword } = req.body;

    // 调用修改密码服务
    const result = await changeUserPassword(user.id, currentPassword, newPassword);

    // 记录日志
    logInfo('用户修改密码成功', { userId: user.id });

    // 返回成功响应
    return res.status(200).json({
      success: true,
      message: '密码修改成功'
    });
  } catch (error) {
    // 记录错误日志
    logError('用户修改密码失败', { error: error.message, userId: req.user?.id });

    // 返回错误响应
    if (error.message === '当前密码错误' || error.message === '用户不存在') {
      return res.status(400).json({
        success: false,
        message: error.message
      });
    }

    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

module.exports = {
  registerUser,
  loginUser,
  getCurrentUser,
  updateUserProfile,
  sendVerificationCodeHandler,
  changePassword
};